package basicx.oop.oc


/*-*- coding:utf-8 -*-
* @Author  : ygree 
* @Time    : 2021/7/2 2:46
* @Software : IntelliJ IDEA
*/

private class Basic {
    private interface MyInterface {
        var name: String  // name 属性, 抽象的,不能设置默认值
        var age: Int  // name 属性, 抽象的,不能设置默认值
        fun bar()  //需要继承初始化
        fun foo() { // 默认
            // 可选的方法体
            println("MyInterface foo")
        }
    }

    // 一个类或者对象可以实现一个或多个接口。
    class Child : MyInterface {
        override var name: String = "" //初始化
            get() = field
            set(value) {
                field = value
            }
        override var age: Int
        override fun bar() {
            println("Child bar")
        }

        init {
            age = 10
        }
    }
}

private  fun main() {
    val c = Basic.Child()
    println("c.name,c.age : ${c.name}:${c.age}")
    c.foo()
    c.bar()
}

private class Mut {
//    函数重写
//    实现多个接口时，可能会遇到同一方法继承多个实现的问题。例如:

    //    实例
    interface A {
        fun foo() {
            println("A.foo")
        } // 已实现

        fun bar() // 未实现，没有方法体，是抽象的
    }

    interface B {
        fun foo() {
            println("B.foo")
        } // 已实现

        fun bar() {
            println("B.bar")
        } // 已实现
    }

    class C : A {
        override fun bar() {
            println("bar")
        } // A未实现，C需要重写
    }

    /** 从 A 和 B 派生 D，需要实现多个接口继承的所有方法，并指明 D 应该如何实现它们。
    这一规则 既适用于继承单个实现（bar()）的方法也适用于继承多个实现（foo()）的方法。*/
    class D : A, B {
        override fun foo() {
            println("--D.foo--")
            super<A>.foo() // 重写指定接口的方法
            println("-A-B-")
            super<B>.foo()
        }

        override fun bar() {
            println("--D.bar--")
            super<B>.bar()
        }
    }
    companion object{
        @JvmStatic
        fun main(args: Array<String>) {
            val d = D()
            d.foo()
            d.bar()
        }
    }

}
